⚡ TITAN WOMB - GUIDE COMPLET ⚡

🛠️ ÉTAPE 0 : MATÉRIEL & LOGICIELS

Liste du Matériel

Où choper le matos ?

• RPi 5 : PiShop (~100€) ou eBay (~50€ mini-PC).
• HackRF : GreatScott (~300€) ou DIY RTL-SDR + ampli (~50€, AliExpress).
• Powerbank : Anker (~20€), fusible 5A (~2€ AliExpress).
• Solaire : Amazon (~30€), MPPT DIY (~15€ AliExpress).
• Antenne : Amazon (~15€), ou Yagi (~25€).
• Boîtier : AliExpress (~10€), ou récup (~5€ + silicone).

Installation Logicielle

# Sur Raspberry Pi OS Lite
sudo apt update
sudo apt install gqrx hackrf gr-osmosdr python3 python3-pip batman-adv
pip install pyhackrf cryptography pysdr numpy pyqt5

📡 ÉTAPE 1 : DÉTECTION DES FRÉQUENCES LIBRES

Script frequency_scanner.py

import numpy as np
from pyhackrf import HackRF
import time

def scan_white_spaces(start_freq=50e6, end_freq=6e9, step=1e6, threshold=-60):
    sdr = HackRF()
    sdr.sample_rate = 10e6  # 10 MHz
    sdr.center_freq = start_freq
    free_frequencies = []
    
    while sdr.center_freq <= end_freq:
        samples = sdr.read_samples(1024)
        power = 10 * np.log10(np.mean(np.abs(samples)**2))  # Puissance en dBm
        if power < threshold:
            free_frequencies.append(sdr.center_freq / 1e6)  # MHz
        sdr.center_freq += step
        time.sleep(0.01)  # Anti-surchauffe
    
    sdr.close()
    return free_frequencies

if __name__ == "__main__":
    print("[+] Scan en cours... Patience, nomade !")
    free_freqs = scan_white_spaces()
    print(f"Fréquences libres (MHz) : {free_freqs}")

🌐 ÉTAPE 2 : RÉSEAU MESH FURTIF

Protocole "Ghost Birth"

1. Nœud émet beacon crypté
2. Réponse aléatoire des nœuds
3. Mesh via B.A.T.M.A.N. Advanced

Script ghost_beacon.py

import time, random, os
from cryptography.hazmat.primitives import hashes

class GhostNode:
    def __init__(self, freqs):
        self.node_id = hashes.Hash(hashes.SHA256()).update(
            str(time.time()).encode()).finalize()[:8]
        self.freqs = freqs

    def send_beacon(self):
        freq = random.choice(self.freqs)
        os.system(f"hackrf_transfer -f {int(freq * 1e6)} -t beacon_{self.node_id.hex()}.raw -s")
        print(f"[+] Beacon sur {freq} MHz : ID={self.node_id.hex()}")

    def listen(self):
        freq = random.choice(self.freqs)
        print(f"[+] Écoute sur {freq} MHz...")
        time.sleep(random.uniform(1, 5))

def setup_mesh(free_freqs):
    node = GhostNode(free_freqs)
    while True:
        node.send_beacon()
        node.listen()
        time.sleep(random.uniform(5, 15))

if __name__ == "__main__":
    free_freqs = [433, 868, 2400]  # Remplace par scan
    print("[+] Lancement mesh furtif...")
    setup_mesh(free_freqs)

Setup Mesh B.A.T.M.A.N.

sudo modprobe batman-adv
sudo batctl if add wlan0
sudo ip link set up dev bat0

🔐 ÉTAPE 3 : CHIFFREMENT & BLOCKCHAIN

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms
from os import urandom

key = urandom(32)  # À partager
nonce = urandom(24)

def encrypt_ghost(data):
    cipher = Cipher(algorithms.ChaCha20(key, nonce), mode=None)
    encryptor = cipher.encryptor()
    return encryptor.update(data)

def decrypt_ghost(ciphertext):
    cipher = Cipher(algorithms.ChaCha20(key, nonce), mode=None)
    decryptor = cipher.decryptor()
    return decryptor.update(ciphertext)

# Test
msg = b"Liberté ou rien"
encrypted = encrypt_ghost(msg)
print(f"Chiffré : {encrypted.hex()}")
print(f"Déchiffré : {decrypt_ghost(encrypted)}")

import hashlib, time

class Block:
    def __init__(self, data, previous_hash):
        self.data = data + str(time.time()).encode()
        self.previous_hash = previous_hash
        self.hash = self.calculate_hash()

    def calculate_hash(self):
        return hashlib.sha256(self.data + self.previous_hash).hexdigest()

blockchain = [Block(b"Genesis", b"0")]
new_block = Block(b"Ghost Message", blockchain[-1].hash)
blockchain.append(new_block)

💀 ÉTAPE 4 : AUTODESTRUCTION & FURTIVITÉ

import os, time, RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.IN)  # Bouton effet Hall

def wipe_and_die():
    os.system("dd if=/dev/zero of=/dev/shm bs=1M")
    os.system("rm -rf /tmp/*")
    os.system("hackrf_transfer -f 868000000 -t noise.raw -s")
    os.system("reboot")

while True:
    if GPIO.input(18) == GPIO.HIGH:  # Aimant retiré
        print("[!] Kill switch activé !")
        wipe_and_die()
    time.sleep(1)

Optimisations

# Réduire conso
sudo apt install powertop
sudo powertop --auto-tune

# Désactiver LEDs
echo "dtparam=act_led_trigger=none" >> /boot/config.txt

🚀 ÉTAPE 5 : RÉSUMÉ & DÉPLOIEMENT

Procédure Finale

1. Assemble matériel (RPi, HackRF, solaire)
2. Scan fréquences libres (50 MHz-6 GHz)
3. Lance réseau mesh (B.A.T.M.A.N. + beacons)
4. Chiffre comms (XChaCha20 + blockchain)
5. Active kill switch après usage